GoFundMe GraphQL API

Getting started

Welcome to our platform! This guide will help you get started with our services.

Step 1: Log in to Partner page

1. Go to the Partner page.
2. Log in with your credentials.
3. If you can't log in or can't find your company, contact GoFundMe support for assistance.

Step 2: Get your Partner code

1. Once you can see your partner dashboard, you should see a referral link at the bottom of the dashboard e.g. https://gofundme.com/partners/create/{code}
2. The last segment of that link is your partnership's unique referral code

Step 3: Create an API key

1. Click on your company button in the top right corner.
2. Select "Account".
3. At the bottom, you have the option to create an API key.
4. Create a new API key and save it somewhere secure, as you will only be able to view it once.

Step 4: Set up your request

1. Open Postman (or your preferred tool for sending POST requests).
2. Set the request type to POST.
3. Use the URL https://graphql.gofundme.com/graphql.
4. Add headers:
   • x-partner-code: Your partner code
   • x-api-key: Your API key
5. Add your GraphQL query as the POST body (see example query below)
6. Send the request

curl --location 'https://graphql.gofundme.com/graphql' \
--header 'x-partner-code: YOUR_PARTNER_CODE' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{"query":"query { partner { code name}}"}'

query {
   partner {
    code
    name
  }
}

If you provided your key correctly, you should get back a response containing your partnership's name and code.

{
  "data": {
    "partner": {
      "code": "GFM",
      "name": "GoFundMe"
    }
  }
}

Next steps

Congratulations! You have successfully completed the getting started guide. Here are some next steps to explore:

• Explore additional GraphQL queries such as https://docs.gofundme.com/#query-fundraiser or https://docs.gofundme.com/#query-charitySearch
• Integrate the API responses into your application.

Searching for charities

This guide will help you get started with searching for charities supported by GoFundMe or retrieving specific charity details using the nonprofit’s PPGF ID.

How it works

The charitySearch query allows you to retrieve a list of charities that GoFundMe supports based on keywords. This can be used to offer users an option to search for charities to select as a beneficiary for their fundraiser.

The charityByPaypalNonprofitId query allows you to retrieve details of a specific charity using the PPGF ID of that nonprofit. This endpoint is useful for determining which GoFundMe ID a charity has if a pre-selected charity will be the beneficiary of the fundraiser.

Example use cases

charitySearch

Let’s say you want to allow your users to search for any nonprofit to fundraiser for out of the list of available GoFundMe beneficiaries in a particular country. Pass the user’s search term into charitySearch and display the corresponding response back to the user to allow them to select which charity they would like to fundraise for. We encourage using the charity’s npoId (PPGF ID) in the fundraiserCreateDraft mutation.

Search for Red Cross with a country filter GB and return:

• GoFundMe ID
• PPGF ID
• Charity Name
• Charity Country

Query example:

{
  charitySearch(searchTerm: "red cross", filter: {
    countryCode: "GB"
  }) {
    id
    npoId
    name
    country
  }
}

Response:

{
  "data": {
    "charitySearch": [
      {
        "id": "4",
        "npoId": "12345",
        "name": "British Red Cross",
        "country": "GB"
      }
    ]
  }
}

charityByPaypalNonprofitId

Now let’s say you want to enable one (or several) pre-selected charities to the beneficiary. To find the GoFundMe ID for that specific charity, to use as a CharityInput in fundraiserCreateDraft, query charityByPaypalNonprofitId using the corresponding PPGF ID as a parameter.

Search a charity given its PPGF ID and return:

• GoFundMe ID
• Charity Name
• Charity Description

Query example:

{
  charityByPaypalNonprofitId(paypalNonprofitId: 14886) {
    npoId
    name
  }
}

Response:

{
  "data": {
    "charityByPaypalNonprofitId": {
      "npoId": "14886",
      "name": "British Red Cross"
    }
  }
}

Connecting to GoFundMe via oAuth

When working with the GoFundMe API your application may need to perform actions directly on behalf of a user. Each user will need to authenticate with GoFundMe to verify their identity and to give your application permission to use and access their data.

OAuth 2.0 is a protocol that allows third-party applications to authenticate with APIs. OAuth 2.0 facilitates two main actions: obtaining an access token through user authorization, and using that access token to make API requests. At the end of a successful OAuth 2.0 exchange, an access token is returned to your application. You will need to submit this token with each API request in order to properly identify your application and access end-user data in a secure manner.

Your application does not need to store or transmit user account names or passwords, but instead relies on application credentials in the form of a Client ID and Client Secret that are unique to your application. The OAuth 2.0 protocol uses these credentials as part of an authorization step in which the user chooses to allow (or deny) your application access their data in GoFundMe. An end user may revoke access granted to your application at any time.

If you are brand new to OAuth 2.0, you can review the official OAuth 2.0 specification. See their Community Resources section for some simplified explanations.

Credentials

There are two credentials that you will need to exercise the OAuth 2.0 Authorization Code Flow: Client ID and Client Secret. You can reach out to GoFundMe to obtain these. Your Client Secret is sensitive and should be stored securely. Never expose your Client Secret in client-facing code e.g. a browser or installed mobile app.

Obtaining Consent

To initiate an OAuth2.0 authorization code flow, you can construct and direct your user to the authorize URL:

https://auth.gofundme.com/oauth2/v1/apps/authorize?response_type=code&client_id={client_id}&redirect_uri={redirect_uri}&scope=openid%20fundraiser:create%20fundraiser:edit&state={state}

Request Parts

• response_type=code: This indicates that you are initiating the Authorization Code Flow (which is the only flow we support)
• client_id: This tells us which client is making the request, and allows us to display your branding on our consent page
• redirect_uri: This is where the user will be automatically redirected upon completing the consent flow
• scope: These are the specific permissions that you are requesting to perform on behalf of a user. For instance, the scope fundraiser:create will let you create a fundraiser directly on behalf of a user
  • openid: includes the OIDC id_token in the token response
  • fundraiser:create: needed for fundraiserCreateDraft
  • fundraiser:edit: needed for fundraiserPublish
  • fundraiser:view: needed for viewer.involvedFundraisers
• state: The state parameter helps to mitigate CSRF attacks, and can also provide you a way to store state that you want to be returned in the redirect. This value should be unique for each new call to /authorize

Token Exchange

Once a user authenticates and completes the consent flow, they will be redirected back to the redirect_uri that was provided to the /authorize request along with an additional code query parameter: {redirect_uri}?code={code}&state={state}

Note: the state value will be identical to what was initially provided to /authorize Using the received code in combination with your Client Secret you can now use the /token endpoint to retrieve an access_token which allows you to act specifically on behalf of the consenting user.

For this request to succeed, you will need to provide your Client ID and Client Secret using the Authorization header in the following base64 encoded format:

Authorization: Basic <Base64(client_id:client_secret)>

For example, with a client_id of 123 and client_secret secret, the expected Authorization header becomes: Authorization: Basic MTIzOnNlY3JldA==

Note: MTIzOnNlY3JldA== is 123:secret base64 encoded.

Additionally, you will need to provide the code in the POST body. A complete example request for the above scenario would look like:

curl --location '<https://auth.gofundme.com/oauth2/v1/apps/token>' \\
--header 'Authorization: Basic MTIzOnNlY3JldA==' \\
--header 'Content-Type: application/x-www-form-urlencoded' \\
--data-urlencode 'grant_type=authorization_code' \\
--data-urlencode 'code=3fa0ed2389a5492e94626606ccb0f9e35deed098cb3dde2abce59f2c508132a6'

The response will follow the format:

{
    "access_token": "{jwt}",
    "token_type": "Bearer",
    "refresh_token": "{jwt}",
    "id_token": "{jwt}",
    "expires_in": 600
}

These tokens are short-lived, and intended to be ephemeral. In the case that a user revokes their consent to your application, your tokens will become invalid.

Using Access Tokens

Once you have obtained an access_token, you will be able to make requests directly on behalf of your user. You will only be able to make requests that fall within what the user consented to during the /authorize step.

To make a request on behalf of a user, you simply need to provide the access_token as an Authorization header following the format: Authorization: Bearer {access_token}

Having done that, you will be able to perform fundraiserCreateDraft (see Creating Fundraisers via API) or other mutations directly on behalf of the user.

A complete example request looks like:

curl --location '<https://graphql.gofundme.com/graphql>' \\
--header 'Authorization: Bearer {access_token}' \\
--header 'Content-Type: application/json' \\
--data-raw '{
  "query": "mutation fundraiserCreateDraft($title: String!) {
    fundraiserCreateDraft(input: {
      title: $title
    }) {
      fundraiser {
        title
      }
    }
  }",
  "variables": {
    "title": "My Fundraiser Title"
  }
}'

Creating and launching fundraisers via API

This guide will help you get started with programmatically creating and publishing fundraisers on GoFundMe.

How it works

The fundraiserCreateDraft mutation allows you to create a draft for a new fundraiser. The partnerPhotoUpload mutation is used in the create process to upload an image and then supply the fundraiserCreateDraft with an image URL.

The fundraiserPublish mutation allows you to publish the created fundraiser. The fundraiser will not be live to the user until it is published.

Example use cases

partnerPhotoUpload

First, upload an image to be used as the cover media for the fundraiser, using the partnerPhotoUpload mutation. Because the request must be multipart/form-data, how your query is structured will vary based on which graphql client you are using. Regardless of which client you use, you must also provide graphql-require-preflight: true on this request because it is multipart.

CURL example:

curl --location 'https://graphql.gofundme.com/graphql' \
--header 'graphql-require-preflight: true' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'x-partner-code: YOUR_PARTNER_CODE' \
--form 'operations={"query":"mutation partnerPhotoUpload($input: Upload!) { partnerPhotoUpload(input: $input) { id url fileSize fileType createdAt}}", "variables":{"input":null}}'
--form 'map={"0": ["variables.input"]}' \
--form '0=@"/path/to/local/file/file.png"'

Response:

{
    "data": {
        "partnerPhotoUpload": {
            "id": "59",
            "url": "https://www.gofundme.com/partnerassets/pitdev/partner-uploads/1722550606/ca7a4e16-5ac6-4c18-a1be-7bcce969bd08.jpeg",
            "fileSize": 15273,
            "fileType": "image/jpeg",
            "createdAt": "2024-08-01T17:16:47.000-05:00"
        }
    }
}

fundraiserCreateDraft

Then create a draft fundraiser, calling the fundraiserCreateDraft mutation with required inputs. Note: use the URL from the response of partnerPhotoUpload as the mediaUrl.

• country
• category
• beneficiaryType
• charity (if beneficiaryType=CHARITY)
• postalCode
• goalAmount
• title
• description (note: at the moment we do not support full HTML fundraiser descriptions, including emojis)
• mediaUrl

Mutation example (charity fundraiser):

mutation {
  fundraiserCreateDraft(input: {
    title: "A Charity Fundraiser"
    category: MEDICAL
    charity: {
      paypalNonprofitId: 14886
    }
    country: "GB"
    postalCode: "E1 8RU"
    goalAmount: 5000
    beneficiaryType: CHARITY
    mediaUrl: "https://www.gofundme.com/partnerassets/pitdev/partner-uploads/1722481246/5a20d214-6685-4348-9789-57fd1b80d0bd.jpeg"
    partnerAffiliation: {
      sourceApplication: "Another Application"
    }
    description: "We are raising money for the British Red Cross. Please show your support by donating and sharing this fundraiser with your community."
  }) {
    fundraiser {
      slug
      fundId
      title
    }
    userErrors {
      field,
      message
    }
  }
}

To create a fund on behalf of the user, use the PartnerExternalOrganizerInput. This indicates that the fundraiser is being created by the partner, on the user's behalf.

FundraiserInput: {
  PartnerExternalOrganizerInput: {
    firstName: "John",
    lastName: "Doe",
    email: "johndoe@gmail.com",
    emailOptIn: true,
    locale: "en-US"
  }
}

Once published, the API will return a FundraiserResponse object. Inside, the FundraiserResponse.Fundraiser.PartnerExternalInput.organizerInviteUrl field contains a unique URL which should be shared with the user so they can officially claim the fundraiser and connect it to their GoFundMe account. For best results, provide the claim link to the user in your UI. GoFundMe will also send this link via email to the user to maximize the claim experience touchpoints.

Important: the fundraiser will not be fully associated to their GoFundMe account until the user completes the claim process, but they can still fundraise as normal.

Mutation example (individual fundraiser):

mutation {
  fundraiserCreateDraft(input: {
    title: "A Personal Fundraiser"
    category: EMERGENCY
    country: "GB"
    postalCode: "E1 8RU"
    goalAmount: 5000
    beneficiaryType: YOURSELF
    mediaUrl: "https://www.gofundme.com/partnerassets/pitdev/partner-uploads/1722481246/5a20d214-6685-4348-9789-57fd1b80d0bd.jpeg"
    partnerAffiliation: {
      sourceApplication: "Another Application"
    }
    description: "I'm rasing money for my school's wildfire relief efforts. Please show your support by donating and sharing this fundraiser with your community."
  }) {
    fundraiser {
      slug
      fundId
      title
    }
    userErrors {
      field,
      message
    }
  }
}

Response:

{
  "data": {
    "fundraiserCreateDraft": {
      "fundraiser": {
        "slug": "e5957e20-5335-4b8c-b1e3-cd8fc8d5d112",
        "fundId": "59024133",
        "title": "A Charity Fundraiser"
      },
      "userErrors": []
    }
  }
}

fundraiserPublish

To publish the draft fundraiser, use the fundraiserPublish mutation with the fundId from fundraiserCreateDraft as the input.

Mutation example:

mutation {
  fundraiserPublish(id: 59024133) {
    userErrors {
      message
    }
    fundraiser {
      title
      slug
      fundId
    }
  }
}

Response:

{
  "data": {
    "fundraiserPublish": {
      "userErrors": [],
      "fundraiser": {
        "title": "A Charity/ Personal Fundraiser",
        "slug": "a-fundraiser-slug",
        "fundId": "59024133"
      }
    }
  }
}

Additional examples

Automated Goals

Smart Goals is an optional feature that helps high-performing fundraisers raise more by automatically increasing the goal amount once it has been met or surpassed. This gradual adjustment helps maintain momentum and encourages continued donations without the organizer needing to take action.

To enable Smart Goals, use the smartGoalsEnabled field. This feature can be turned off at any time by the fundraiser organizers and by default is off unless explicitly enabled.

FundraiserInput: {
  smartGoalsEnabled: true
}

If Smart Goals are enabled, we recommend showing this copy to the user so they are aware why their goal has changed:

GoFundMe will use data from similar fundraisers to gradually adjust your goal as donations come in, to increase fundraiser success. You can turn this off at any time.

Communications consent

To let GoFundMe contact the organizer with fundraiser best practices, tips, and coaching, include this when creating the fundraiser:

partnerExternalOrganizerInput: {
  emailOptIn: true
}

This allows us to support users directly—improving fundraiser outcomes and increasing the likelihood of success. It’s especially helpful for new organizers who may not know where to start.

Please use the following standard consent language for users to launch their fundraisers:

By clicking on the GoFundMe button above, you agree to have your submitted information used to create a fundraiser on the third-party website or app of our partner GoFundMe, and for GoFundMe to use your information to contact you. You acknowledge that GoFundMe will process your information in accordance with its privacy notice.

If you’re creating a charity-linked fundraiser, and you’d like the nonprofit to receive basic information about the fundraiser creator (such as name and email) so they can provide support or say thank you, include the following.

FundraiserInput: {
  npoMarketingConsent: true
}

This gives the nonprofit visibility into who’s creating fundraisers on their behalf and enables them to deepen relationships with their supporters.

Working with test data

When creating fundraisers for development or testing purposes only, please use the isTestData field.

PartnerAffiliation: {
  isTestData: true
}

This ensures that fundraisers won't appear in GoFundMe search or other public discovery surfaces, that test donations are excluded from core metrics, and a clean separation from production fundraisers.

To further reinforce that these fundraisers are for testing, we recommend including the word "test" or "Test" in the fundraiser title (example: Test Fundraiser for "Partner Name").

Creating Partner fundraisers via referral links

The Partner referral flow is designed to enable partners to refer users to GoFundMe to create fundraisers with minimal development effort on the partner’s end. This is achieved by using specific URL query parameters to pre-fill information where possible, providing a streamlined experience for users and removing steps in the GoFundMe creation user flow.

These fundraisers are attributed to the Partner who refers them through their partnerCode. Attributed fundraisers and donations are accessible in the Partner Dashboard.

How it works

Organizations can refer their users to the Partner flow by appending URL query parameters to their GFM partner link (see partner.gofundme.com for the URL). These query parameters pre-fill specific fields on the fundraiser, reducing the amount of manual input required, and improving the onboarding experience for users.

Below are the supported query parameters.

Parameters able to be passed via referral link

Parameter	Required	Type	Description
zip_code	optional	number	Zip code of the organizer/ fundraiser
country	required	string	Country code of the organizer’s fundraiser (ex: US)
beneficiary_type	optional	string	Beneficiary of the organizer’s fundraiser. Defaults to YOURSELF Options: - YOURSELF - SOMEONE_ELSE
category	optional	string	Category of the fundraiser. See category list
service_date	optional	datetime (UTC) string	Memorial date of the fundraiser. Should only be used with the MEMORIALS category
tp_id	optional	string	A unique external identifier provided by the partner to identify users on GoFundMe’s system. It is used in tandem with other identifiers to ensure a precise mapping of users

Information always collected on GoFundMe (not by the Partner)

Parameter	Description
Goal amount	Target amount to raise
Image	Main image to display on the fundraiser page
Title	Title/ name of the fundraiser
Story	Description of the fundraiser

Examples

Create a Fundraiser with no query params
If no query parameters are passed along with the Partner referral link then the user will be redirected to gofundme.com/create and go through the regular GoFundMe creation process.

https://www.gofundme.com/partners/create/{partnerCode}

Create a Fundraiser with just country as a param
This is the minimum viable set of query parameters to create a draft fundraiser using the streamlined Partner flow. This query uses the required country parameter.

https://www.gofundme.com/partners/create/{partnerCode}?country=US

Create a Fundraiser with country, zip_code, category, beneficiary_type as params

https://www.gofundme.com/partners/create/{partnerCode}?country=US&zip_code=92618&category=Animals&beneficiary_type=YOURSELF

Create a Fundraiser with category, category, service_date, & tp_id as params

https://www.gofundme.com/partners/create/{partnerCode}?country=US&category=Memorials&service_date=2025-01-03T10%3A15%3A30Z&tp_id=01234

Retrieving donations/ fundraisers

This guide will help you get started with querying data to retrieve all the fundraisers or donations associated with fundraisers that were published via your GoFundMe partner account.

How it works

The partner.fundraiser query allows you to retrieve all fundraisers associated with your partner account. The fundraiser.donations query allows you to retrieve all donations to a given fundraiser. The partner.donations query allows you to retrieve all donations to all fundraisers associated with your partner account.

Example use cases

partner.fundraisers

To query all fundraisers associated with your partner account partner.fundraisers.

Query example:

query {
  partner {
    fundraisers {
      edges {
       node {
         title
         description
       }
      }
    }
  }
}

Response:

{
  "data": {
    "partner": {
      "fundraisers": {
        "edges": [
          {
            "node": {
              "title": "Partner Fundraiser 1",
              "description": "A fundraiser description for a test campaign"
            }
          },
          {
            "node": {
              "title": "Partner Fundraiser 2",
              "description": "Another description for a test campaign"
            }
          }
        ]
      }
    }
  }
} 

fundraiser.donations

To query all donations to one particular fundraiser, use fundraiser.donations. Use pagination and hasNextPage to determine when you’ve reached the end of a connection.

Query example:

query {
  fundraiser(slug: "example-campaign") {
    donations {
      pageInfo {
        hasNextPage
        hasPreviousPage
        startCursor
      }
      edges {
        cursor
        node {
          name
          amount {
            currencyCode
            amount
          }
          createdAt
        }
      }
    }
  }
}

Response:

{
  "data": {
    "fundraiser": {
      "donations": {
        "pageInfo": {
          "hasNextPage": true,
          "hasPreviousPage": false,
          "startCursor": "RG9uYXRpb246aWQ6NzYyODM4OTI1"
        },
        "edges": [
          {
            "cursor": "RG9uYXRpb246aWQ6NzYyODM4OTI1",
            "node": {
              "name": "Test Donor",
              "amount": {
                "currencyCode": "USD",
                "amount": 5
              },
              "createdAt": "2023-03-17T12:40:33.000-05:00"
            }
          },
          {
            "cursor": "RG9uYXRpb246aWQ6NzYyODg4ODk1",
            "node": {
              "name": "John Doh",
              "amount": {
                "currencyCode": "USD",
                "amount": 5
              },
              "createdAt": "2023-03-27T16:32:20.000-05:00"
            }
          },
          {
            "cursor": "RG9uYXRpb246aWQ6NzYyODkyODY1",
            "node": {
              "name": "Another Donor",
              "amount": {
                "currencyCode": "USD",
                "amount": 5
              },
              "createdAt": "2023-03-28T13:42:06.000-05:00"
            }
          }
        ]
      }
    }
  }

partner.donations

To query all donations associated with your partner account partner.donations. Use pagination and hasNextPage to determine when you’ve reached the end of a connection.

Query example:

query {
  partner {
    donations {
      pageInfo {
        hasNextPage
        hasPreviousPage
        startCursor
      }
      edges {
       node {
         name
         amount {
          currencyCode
          amount
        }
        fundraiser {
          title
          fundId
        }
       }
      }
    }
  }
}

Response:

{
  "data": {
    "partner": {
      "donations": {
        "pageInfo": {
          "hasNextPage": true,
          "hasPreviousPage": false,
          "startCursor": "RG9uYXRpb246aWQ6NzYxNTg1NjIz"
        },
        "edges": [
          {
            "node": {
              "name": "Archer Woolery",
              "amount": {
                "currencyCode": "USD",
                "amount": 5
              },
              "fundraiser": {
                "title": "Adyen test campaign",
                "fundId": "33760977"
              }
            }
          },
          {
            "node": {
              "name": "Archer Woolery",
              "amount": {
                "currencyCode": "USD",
                "amount": 5
              },
              "fundraiser": {
                "title": "Adyen test campaign",
                "fundId": "33760977"
              }
            }
          },
          {
            "node": {
              "name": "Archer Woolery",
              "amount": {
                "currencyCode": "USD",
                "amount": 5
              },
              "fundraiser": {
                "title": "Adyen test campaign",
                "fundId": "33760977"
              }
            }
          },
          {
            "node": {
              "name": "Product Testing",
              "amount": {
                "currencyCode": "USD",
                "amount": 7
              },
              "fundraiser": {
                "title": "Adyen test campaign",
                "fundId": "33760977"
              }
            }
          },
          {
            "node": {
              "name": "Ksenia Cat",
              "amount": {
                "currencyCode": "USD",
                "amount": 7
              },
              "fundraiser": {
                "title": "Adyen test campaign",
                "fundId": "33760977"
              }
            }
          }
        ]
      }
    }
  }
}

Retrieving a user's fundraisers via OAuth

This guide will help you get started with querying data to retrieve all the fundraisers organized by a user that has consented to share this information with your partner account.

How it works

The viewer.involvedFundraisers query allows you to retrieve fundraisers for the user associated with the OAuth access token you provide. This query will not return data if the access token does not include the fundraiser:view scope.

Example use cases

viewer.involvedFundraisers

Query example:

query {
  viewer {
    involvedFundraisers(
      filter:{
        myRelationships:[ORGANIZER],
        isPublished:true
      },
      first: 50, 
      order:CREATED_AT
    ) {
      edges {
        node {
          fundId
          title
          description
        }
      }
    }
  }
}

Response:

{
  "data": {
    "viewer": {
      "involvedFundraisers": {
        "edges": [
          {
            "node": {
              "fundId": "12345",
              "title": "Test fundraiser 1",
              "description": "test fundraiser description 1"
            }
          },
          {
            "node": {
              "fundId": "123456",
              "title": "Test fundraiser 2",
              "description": "test fundraiser description 2"
            }
          },
          {
            "node": {
              "fundId": "123457",
              "title": "Test fundraiser 3",
              "description": "test fundraiser description 3"
            }
          }
        ]
      }
    }
  }
}